const http = require('http');
const socketIo = require('socket.io');

// 创建HTTP服务器
const server = http.createServer();

// 创建Socket.IO服务器
const io = socketIo(server, {
  cors: {
    origin: "*",
    methods: ["GET", "POST"]
  }
});

// 存储连接的客户端
const clients = new Set();

console.log('Socket.IO服务器启动在 http://localhost:8080');

io.on('connection', (socket) => {
  console.log('新客户端连接:', socket.id);
  clients.add(socket);
  
  // 发送欢迎消息
  socket.emit('message', {
    type: 'system',
    content: '欢迎使用Socket.IO聊天服务器！'
  });
  
  // 处理异步匹配请求
  socket.on('start_async_match', (data) => {
    try {
      console.log('收到异步匹配请求:', data);
      
      // 模拟匹配处理
      simulateAsyncMatch(socket, data);
    } catch (error) {
      console.error('处理异步匹配请求失败:', error);
      socket.emit('match_update', {
        type: 'error',
        content: '匹配请求处理错误'
      });
    }
  });
  
  // 处理同步匹配请求
  socket.on('start_match', (data) => {
    try {
      console.log('收到同步匹配请求:', data);
      
      // 模拟同步匹配处理
      simulateSyncMatch(socket, data);
    } catch (error) {
      console.error('处理同步匹配请求失败:', error);
      socket.emit('match_update', {
        type: 'error',
        content: '同步匹配请求处理错误'
      });
    }
  });
  
  // 处理审核响应
  socket.on('audit_response', (data) => {
    try {
      console.log('收到审核响应:', data);
      
      // 处理审核结果
      handleAuditResponse(socket, data);
    } catch (error) {
      console.error('处理审核响应失败:', error);
      socket.emit('audit_update', {
        type: 'error',
        content: '审核响应处理错误'
      });
    }
  });
  
  // 处理数据请求（保持兼容性）
  socket.on('request_data', (data) => {
    try {
      console.log('收到数据请求:', data);
      sendTableData(socket, data.content, data.sessionId);
    } catch (error) {
      console.error('处理数据请求失败:', error);
    }
  });
  
  socket.on('disconnect', () => {
    console.log('客户端断开连接:', socket.id);
    clients.delete(socket);
  });
  
  socket.on('error', (error) => {
    console.error('Socket.IO错误:', error);
    clients.delete(socket);
  });
});

// 模拟异步匹配处理
function simulateAsyncMatch(socket, matchData) {
  const requestId = Date.now().toString();
  console.log(`开始异步匹配处理，请求ID: ${requestId}`);
  
  // 发送匹配开始消息
  socket.emit('match_update', {
    request_id: requestId,
    content: `开始处理匹配请求：${matchData.main_req}\n预算：${matchData.budget}\n目标粉丝：${matchData.fans_req}`
  });
  
  // 模拟匹配过程中的更新
  setTimeout(() => {
    if (socket.connected) {
      socket.emit('match_update', {
        request_id: requestId,
        content: `正在分析需求：${matchData.main_req}\n已找到 3 个潜在匹配...`
      });
    }
  }, 1000);
  
  // 模拟需要审核的情况 - 发送第一个审核请求
  setTimeout(() => {
    if (socket.connected) {
      const auditId1 = requestId + '_audit_1_' + Date.now();
      socket.emit('audit_request', {
        request_id: auditId1,
        audit_data: {
          original_keywords: matchData.main_req,
          mapped_keywords: `优化后的关键词1：${matchData.main_req} + 专业推广`
        }
      });
      console.log('发送第一个审核请求:', auditId1);
    }
  }, 1000);

  // 模拟需要审核的情况 - 发送第二个审核请求
  setTimeout(() => {
    if (socket.connected) {
      const auditId2 = requestId + '_audit_2_' + Date.now();
      socket.emit('audit_request', {
        request_id: auditId2,
        audit_data: {
          original_keywords: matchData.main_req,
          mapped_keywords: `优化后的关键词2：${matchData.main_req} + 精准投放`
        }
      });
      console.log('发送第二个审核请求:', auditId2);
    }
  }, 2000);

  // 模拟需要审核的情况 - 发送第三个审核请求
  setTimeout(() => {
    if (socket.connected) {
      const auditId3 = requestId + '_audit_3_' + Date.now();
      socket.emit('audit_request', {
        request_id: auditId3,
        audit_data: {
          original_keywords: matchData.main_req,
          mapped_keywords: `优化后的关键词3：${matchData.main_req} + 品牌合作`
        }
      });
      console.log('发送第三个审核请求:', auditId3);
    }
  }, 3000);
  
  // 模拟最终匹配完成
  setTimeout(() => {
    if (socket.connected) {
      socket.emit('match_complete', {
        request_id: requestId,
        content: `匹配完成！\n找到 5 个符合条件的达人\n预计投放效果：曝光量 10万+`
      });
      console.log('异步匹配处理完成');
    }
  }, 5000);
}

// 模拟同步匹配处理
function simulateSyncMatch(socket, matchData) {
  const requestId = Date.now().toString();
  console.log(`开始同步匹配处理，请求ID: ${requestId}`);
  
  // 同步匹配立即返回结果
  socket.emit('match_update', {
    request_id: requestId,
    content: `同步匹配结果：\n需求：${matchData.main_req}\n预算：${matchData.budget}\n立即匹配到 2 个达人`
  });
  
  setTimeout(() => {
    if (socket.connected) {
      socket.emit('match_complete', {
        request_id: requestId,
        content: '同步匹配完成！'
      });
      console.log('同步匹配处理完成');
    }
  }, 1000);
}

// 处理审核响应
function handleAuditResponse(socket, auditData) {
  console.log('处理审核响应:', auditData);
  
  const { request_id, audit_result } = auditData;
  
  if (audit_result.is_approved) {
    // 审核通过，继续处理
    socket.emit('audit_update', {
      request_id: request_id,
      content: `审核通过！\n审核分数：${audit_result.audit_score}\n审核意见：${audit_result.comments}\n继续执行匹配流程...`
    });
    
    // 模拟审核通过后的后续处理
    setTimeout(() => {
      if (socket.connected) {
        socket.emit('match_update', {
          request_id: request_id.replace('_audit', ''),
          content: '审核通过，正在执行优化后的匹配策略...'
        });
      }
    }, 1000);
    
  } else {
    // 审核不通过
    socket.emit('audit_update', {
      request_id: request_id,
      content: `审核不通过\n审核分数：${audit_result.audit_score}\n审核意见：${audit_result.comments}\n请重新提交请求`
    });
  }
  
  console.log(`审核结果处理完成: ${audit_result.is_approved ? '通过' : '不通过'}`);
}

// 分析消息内容，判断应该返回什么类型的回复
function analyzeMessage(message) {
  const lowerMessage = message.toLowerCase();
  
  // 操作类关键词
  const actionKeywords = ['推荐', '建议', '方案', '策略', '计划', '优化', '改进', '调整', '修改', '删除', '添加', '创建', '执行', '实施'];
  // 只读类关键词
  const readOnlyKeywords = ['查询', '显示', '展示', '分析', '统计', '报告', '数据', '信息', '状态', '结果', '详情', '说明'];
  
  const hasActionKeywords = actionKeywords.some(keyword => lowerMessage.includes(keyword));
  const hasReadOnlyKeywords = readOnlyKeywords.some(keyword => lowerMessage.includes(keyword));
  
  return {
    hasActionKeywords,
    hasReadOnlyKeywords,
    message: lowerMessage
  };
}

// 根据分析结果生成不同类型的回复
function generateResponses(userMessage, analysis) {
  const responses = [];
  
  // 总是先有一个确认收到消息的回复（只读类）
  responses.push({
    content: `我收到了您的消息: "${userMessage}"`,
    messageType: 'readonly'
  });
  
  // 根据分析结果添加不同类型的回复
  if (analysis.hasActionKeywords) {
    // 添加操作类回复
    responses.push({
      content: `基于您的需求，我建议采取以下行动方案：\n1. 分析当前情况\n2. 制定具体策略\n3. 实施改进措施`,
      messageType: 'action'
    });
    
    responses.push({
      content: `另外，我还可以为您提供以下优化建议：\n- 数据结构优化\n- 性能提升方案\n- 用户体验改进`,
      messageType: 'action'
    });
  }
  
  if (analysis.hasReadOnlyKeywords) {
    // 添加只读类回复
    responses.push({
      content: `根据您的查询，这里是相关的分析结果和数据展示。详细信息请查看右侧数据表格。`,
      messageType: 'readonly'
    });
  }
  
  // 如果没有特定关键词，添加通用回复
  if (!analysis.hasActionKeywords && !analysis.hasReadOnlyKeywords) {
    responses.push({
      content: `这是一个关于"${userMessage}"的详细回复，包含了相关的信息和分析。`,
      messageType: 'readonly'
    });
    
    // 随机添加一个操作类建议
    if (Math.random() > 0.5) {
      responses.push({
        content: `针对"${userMessage}"，我建议您可以考虑以下改进措施，请确认是否采用。`,
        messageType: 'action'
      });
    }
  }
  
  return responses;
}

// 存储会话数据的映射表
const sessionDataMap = new Map();

// 发送表格数据函数
function sendTableData(socket, requestContent, sessionId) {
  console.log('收到数据请求，发送表格数据...会话ID:', sessionId);
  
  if (socket.connected) {
    // 检查是否已有该会话的数据
    let mockTableData;
    
    if (sessionDataMap.has(sessionId)) {
      // 使用已存储的数据
      mockTableData = sessionDataMap.get(sessionId);
      console.log('使用已存储的会话数据');
    } else {
      // 为新会话生成数据
      mockTableData = [
        {
          id: '1',
          name: `会话${sessionId.slice(-4)}的分析结果1`,
          value: Math.floor(Math.random() * 1000),
          category: '类别A',
          status: '正常',
          date: new Date().toLocaleDateString()
        },
        {
          id: '2',
          name: `会话${sessionId.slice(-4)}的分析结果2`,
          value: Math.floor(Math.random() * 1000),
          category: '类别B',
          status: '异常',
          date: new Date().toLocaleDateString()
        },
        {
          id: '3',
          name: `会话${sessionId.slice(-4)}的分析结果3`,
          value: Math.floor(Math.random() * 1000),
          category: '类别A',
          status: '正常',
          date: new Date().toLocaleDateString()
        },
        {
          id: '4',
          name: `会话${sessionId.slice(-4)}的分析结果4`,
          value: Math.floor(Math.random() * 1000),
          category: '类别C',
          status: '警告',
          date: new Date().toLocaleDateString()
        }
      ];
      
      // 存储会话数据
      sessionDataMap.set(sessionId, mockTableData);
      console.log('已生成并存储新的会话数据');
    }
    
    socket.emit('message', {
      type: 'data',
      content: mockTableData,
      sessionId: sessionId
    });
    
    console.log('已发送表格数据:', mockTableData.length, '条');
  }
}

// 处理服务器错误
server.on('error', (error) => {
  console.error('服务器错误:', error);
});

// 启动服务器
server.listen(8080, () => {
  console.log('服务器正在监听端口 8080');
});

// 优雅关闭
process.on('SIGINT', () => {
  console.log('\n正在关闭服务器...');
  
  // 关闭所有客户端连接
  clients.forEach(socket => {
    if (socket.connected) {
      socket.disconnect();
    }
  });
  
  // 关闭Socket.IO服务器
  io.close(() => {
    // 关闭HTTP服务器
    server.close(() => {
      console.log('服务器已关闭');
      process.exit(0);
    });
  });
});

process.on('SIGTERM', () => {
  console.log('\n收到SIGTERM信号，正在关闭服务器...');
  
  // 关闭所有客户端连接
  clients.forEach(socket => {
    if (socket.connected) {
      socket.disconnect();
    }
  });
  
  // 关闭Socket.IO服务器
  io.close(() => {
    // 关闭HTTP服务器
    server.close(() => {
      console.log('服务器已关闭');
      process.exit(0);
    });
  });
});